home *** CD-ROM | disk | FTP | other *** search
/ Graphics Plus / Graphics Plus.iso / general / plotting / imagetoo / imagetl1.lha / Imagetool / src+obj / new.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-09-20  |  13.8 KB  |  563 lines
  1. /*
  2. ******************************************************************************
  3. *                               NCSA ImageTool 1.1 beta
  4. *                           Thu Sep 20 16:58:25 CDT 1990
  5. * 
  6. * NCSA ImageTool 1.1 beta source code and documentation are in the public
  7. * domain.
  8. * Specifically, we give to the public domain all rights for future licensing
  9. * of the source code, all resale rights, and all publishing rights.
  10. * 
  11. * We ask, but do not require, that the following message be included in all
  12. * derived works:
  13. * 
  14. * Portions developed at the National Center for Supercomputing Applications at
  15. * the University of Illinois at Urbana-Champaign.
  16. * 
  17. * THE UNIVERSITY OF ILLINOIS GIVES NO WARRANTY, EXPRESSED OR IMPLIED, FOR THE
  18. * SOFTWARE AND/OR DOCUMENTATION PROVIDED, INCLUDING, WITHOUT LIMITATION,
  19. * WARRANTY OF MERCHANTABILITY AND WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE
  20. * 
  21. ******************************************************************************
  22. */
  23. /* cat > headers/new.h << "EOF" */
  24. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  25. /* new.h: header for new.c file                */
  26. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  27. /* SCCS information: %W%    %G% - NCSA */
  28.  
  29. #include "all.h"
  30. #include "newext.h"
  31.  
  32. /* EOF */
  33. /* cat > src+obj/new/check_filetype.c << "EOF" */
  34. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  35. /* check_filetype: check whether a file is a file or a  */
  36. /*           directory is a directory.        */
  37. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  38. /* SCCS information: %W%    %G% - NCSA */
  39.  
  40. /* #include "all.h" */
  41. /* #include "newext.h" */
  42.  
  43. int
  44. check_filetype (path, type)
  45.                 /* returns: 0 - correct type
  46.                        -1 - wrong type */
  47.     char           *path;
  48.                 /* input: must be full legal pathname */
  49.     int             type;
  50.                 /* input: TYPE_DIR  - directory
  51.                       TYPE_FILE - file */
  52. {
  53.         /* check if wrong type */
  54.     if (type == TYPE_DIR)
  55.     {        /* directory */
  56.         sprintf (wkstr, "csh -fc \"test -d '%s'\"", path);
  57.         if (check_system (wkstr))    /* 0 exit status means true */
  58.             return (-1);
  59.     }
  60.     else if (type == TYPE_FILE)
  61.     {        /* file */
  62.         sprintf (wkstr, "csh -fc \"test -f '%s'\"", path);
  63. /* printf */
  64. /* msg_write (wkstr); */
  65.         if (check_system (wkstr))    /* 0 exit status means true */
  66.             return (-1);
  67.     }
  68.     return (0);
  69. }
  70. /* EOF */
  71. /* cat > src+obj/new/check_system.c << "EOF" */
  72. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  73. /* check_system: send a command to the system () C    */
  74. /*         library function and return success or    */
  75. /*         failure. Standard error is redirected    */
  76. /*         to the bit bucket.            */
  77. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  78. /* SCCS information: %W%    %G% - NCSA */
  79.  
  80. /* #include "all.h" */
  81. /* #include "newext.h" */
  82.  
  83. int 
  84. check_system (s)
  85.                 /* returns  0 = success
  86.                        -1 = failure */
  87.     char           *s;
  88.                 /* input: command string */
  89. {
  90. /* Implementation note(s):
  91.     1. Use /dev/null as the bit bucket.
  92. */
  93.  
  94.     int             newd;
  95.  
  96.         /* stderr (fd = 2) should go to /dev/null */
  97.     newd = dup (2);
  98.     close (2);
  99.  
  100.     (void) open ("/dev/null", O_WRONLY);    /* should not fail - opens on 2 */
  101.  
  102.     if (system (s))    
  103.     {
  104.         (void) dup2 (newd, 2);
  105.         close (newd);
  106.         return (-1);
  107.     }
  108.     else
  109.     {        /* 0 exit means true */
  110.         (void) dup2 (newd, 2);
  111.         close (newd);
  112.         return (0);
  113.     }
  114. }
  115. /* EOF */
  116. /* cat > src+obj/new/first_word.c << "EOF" */
  117. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  118. /* first_word: get first word in a string. White space    */
  119. /*           is space or tab.                */
  120. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  121. /* SCCS information: %W%    %G% - NCSA */
  122.  
  123. /* #include "all.h" */
  124.  
  125. char           *
  126. first_word (s, len)
  127.                 /* returns: pointer to first character of word */
  128.     char           *s;
  129.                 /* input: string to locate first word */
  130.     int            *len;
  131.                 /* returns: length of word in characters */
  132. {
  133.     register int    c;
  134.  
  135.         /* strip off any leading white space */
  136.     *len = 0;
  137.     while ((c = *s++) != NULL)
  138.         if (c != ' ' && c != '\t')
  139.         {
  140.             (*len)++;
  141.             break;
  142.         }
  143.  
  144.         /* scan the word */
  145.     while ((c = *s++) != NULL)
  146.         if (c == ' ' || c == '\t')
  147.             break;
  148.         else
  149.             (*len)++;
  150.  
  151.     return (s - *len - 1);
  152. }
  153. /* EOF */
  154. /* cat > src+obj/new/free_list.c << "EOF" */
  155. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  156. /* free_list: free storage associate with a char **    */
  157. /*          variable from wildcard.            */
  158. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  159. /* SCCS information: %W%    %G% - NCSA */
  160.  
  161. /* #include "all.h" */
  162. /* #include "newext.h" */
  163.  
  164. int 
  165. free_list (var)
  166.     char          **var;
  167. {
  168.     int i;
  169.  
  170.         /* if there are no files - var points to one location with
  171.            a NULL pointer */
  172.     if (var[0] == NULL)
  173.         return;
  174.     else
  175.     {
  176.         i = 0;
  177.         while (var[i] != NULL)
  178.             free (var[i++]);
  179.     }
  180.     free (var);
  181.     return;
  182. }
  183. /* EOF */
  184. /* cat > src+obj/new/get_abspathname.c << "EOF" */
  185. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  186. /* get_abspathname: resolve a path to an absolute     */
  187. /*            pathname. The intended type, file    */
  188. /*            or directory must be provided.    */
  189. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  190. /* SCCS information: %W%    %G% - NCSA */
  191.  
  192. /* #include "all.h" */
  193. /* #include "newext.h" */
  194.  
  195. int 
  196. get_abspathname (fn, maxfnlen, type)
  197.                 /* returns:
  198.                     error - 0 = no error
  199.                         1 = no such type
  200.                         2 = wrong type
  201.                         3 = no pathname
  202.                         4 = multiple pathnames
  203.                         5 = ambiguous type - wildcard 
  204.                         6 = syntax - wildcard (error 1)
  205.                         7 = memory allocation -
  206.                             wildcard (error 2) -
  207.                             internal
  208.                         8 = not enough string space in
  209.                             argument - internal
  210.                         9 = pathname for current
  211.                             directory failed - internal
  212.                            10 = change directory failed
  213.                             - internal
  214.                            11 = pathname for new directory
  215.                             failed - internal
  216.                            12 = NULL pointer to fn -
  217.                             internal
  218.                            13 = nonpositive maxfnlen
  219.                             value - internal
  220.                            14 = bad type value - internal */
  221.     char           *fn;
  222.                 /* input: relative or absolute pathname that
  223.                           would be parsed correctly by the
  224.                       C-shell. Multiple pathnames result
  225.                       in an error.
  226.                    returns: (no error) the absolute pathname
  227.                         fully resolved provided the length
  228.                         is not greater than maxfnlen - 1.
  229.                         (error) orginal string is
  230.                         returned. */
  231.     int             maxfnlen;
  232.                 /* input: maximum length of final path + 1 of
  233.                       filename storage for fn. */
  234.     int             type;
  235.                 /* input: TYPE_DIR  - directory
  236.                       TYPE_FILE - file */
  237. {
  238.     int             nt, err, fnlen, fflen, cdlen;
  239.     char          **path;
  240.     char           *fpart, *pwd, *new_pwd;
  241.  
  242.     char           *getcwd ();    /* standard C library */
  243.  
  244.         /* bad arguments */
  245.     if (fn == NULL)
  246.         return (12);
  247.     else if (maxfnlen < 1)
  248.         return (13);
  249.     else if (type < 0 || type > 1)
  250.         return (14);
  251.  
  252.     if ((nt = word_count (fn)) != 1)
  253.     {        /* incorrect number of "tokens" */
  254.         if (nt == 0)
  255.             return (3);    /* no pathname */
  256.         else
  257.             return (4);    /* too many potential paths */
  258.     }
  259.  
  260.     path = wildcard (fn, &err);
  261.  
  262. /* printf */
  263. /* sprintf (wkstr, "path = %s", path[0]);
  264. msg_write (wkstr); */
  265.     if (err != 0)
  266.     {        /* wildcard error */
  267.         if (err == 1)
  268.             return (6);    /* syntax */
  269.         else
  270.             return (7);    /* memory allocation */
  271.     }
  272.     if (path[0] == NULL)    /* no match */
  273.         return (1);
  274.     else if (path[1] != NULL)    /* ambiguous filename */
  275.     {
  276.         (void) free_list (path);
  277.         return (5);
  278.     }
  279.     if ((fnlen = strlen (path[0])) > maxfnlen - 1)    /* not enought string space */
  280.     {
  281.         (void) free_list (path);
  282.         return (8);
  283.     }
  284.  
  285.         /* build full pathname */
  286.     pwd = getcwd ((char *) NULL, MAXNAMELEN + 1);    /* must free before return */
  287.     if (pwd == NULL)    /* size too small or internal error */
  288.     {
  289.         (void) free_list (path);
  290.         return (9);
  291.     }
  292.     cdlen = strlen (pwd);
  293.     if (type == TYPE_FILE)    /* file */
  294.     {
  295.         fpart = strrchr (path[0], '/');    /* find last / */
  296.         if (fpart == NULL)    /* no directory part - use current directory */
  297.         {        /* add 1 for / */
  298.             if ((cdlen + 1 + fnlen) > maxfnlen - 1)    /* not enough string space */
  299.             {
  300.                 (void) free_list (path);
  301.                 free (pwd);
  302.                 return (8);
  303.             }
  304.             sprintf (wkstr2, "%s/%s", pwd, path[0]);
  305. /* printf */
  306. /* msg_write (wkstr2); */
  307.             if (check_filetype (wkstr2, type))
  308.             {
  309.                 (void) free_list (path);
  310.                 free (pwd);
  311.                 return (2);
  312.             }
  313.             strcpy (fn, wkstr2);
  314.             (void) free_list (path);
  315.             free (pwd);
  316.             return (0);
  317.         }
  318.         fflen = strlen (fpart) - 1;
  319.         *fpart = '\0';    /* temporary make path[0] point just to the directory part */
  320.     }
  321.     if (chdir (path[0]))    /* if problem then internal error */
  322.     {
  323.         (void) free_list (path);
  324.         free (pwd);
  325.         return (10);
  326.     }
  327.     new_pwd = getcwd ((char *) NULL, MAXNAMELEN + 1);    /* must free before return */
  328.     if (new_pwd == NULL)    /* size too small or internal error */
  329.     {
  330.         (void) free_list (path);
  331.         free (pwd);
  332.         return (11);
  333.     }
  334.     cdlen = strlen (new_pwd);
  335.     if (type == TYPE_DIR)
  336.     {        /* directory */
  337.         strcpy (wkstr2, new_pwd);
  338.         if (check_filetype (wkstr2, type))
  339.         {
  340.             (void) free_list (path);
  341.             free (pwd);
  342.             free (new_pwd);
  343.             return (2);
  344.         }
  345.         strcpy (fn, new_pwd);
  346.     }
  347.     else if (type == TYPE_FILE)    /* file */
  348.     {        /* add 1 for / */
  349.         if ((cdlen + 1 + fflen) > maxfnlen - 1)
  350.         {        /* not enough string space */
  351.             (void) free_list (path);
  352.             (void) chdir (pwd);    /* should not error */
  353.             free (pwd);
  354.             free (new_pwd);
  355.             return (8);
  356.         }
  357.         sprintf (wkstr2, "%s/%s", new_pwd, fpart + 1);
  358.         if (check_filetype (wkstr2, type))
  359.         {
  360.             (void) free_list (path);
  361.             free (pwd);
  362.             free (new_pwd);
  363.             return (2);
  364.         }
  365.         strcpy (fn, wkstr2);
  366.     }
  367.  
  368.     (void) free_list (path);
  369.     (void) chdir (pwd);    /* should not error */
  370.     free (pwd);
  371.     free (new_pwd);
  372.     return (0);
  373. }
  374. /* EOF */
  375. /* cat > src+obj/new/pixrect_pad.c << "EOF" */
  376. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  377. /* pixrect_pad: horizontal padding in bytes for memory  */
  378. /*        pixrect.                */
  379. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  380. /* SCCS information: %W%    %G% - NCSA */
  381.  
  382. /* #include "all.h" */
  383. /* #include "newext.h" */
  384.  
  385. int
  386. pixrect_pad (xdim)
  387.                 /* returns: the number of bytes of
  388.                         horizontal padding */
  389.     int             xdim;
  390.                 /* input: horizontal dimension of memory
  391.                       pixrect */
  392. {
  393. /*
  394.    BUG: mpr_linebytes () is wrong on Sun-3 and Sun-4. It computes padding
  395.         to 16 bits not 32 bits which mem_create uses. Decided not to use it.
  396.     Can't tell when it works!
  397. */
  398. #if sun == sparc || sun == mc68020 || sun == mc68030
  399.     return ((xdim % 4 == 0) ? 0 : 4 - xdim % 4);
  400. #else
  401.     return ((xdim % 2 == 0) ? 0 : 2 - xdim % 2);
  402. #endif
  403. }
  404. /* EOF */
  405. /* cat > src+obj/new/strip_wspace.c << "EOF" */
  406. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  407. /* strip_wspace: strip off leading and trailing white    */
  408. /*         space.                    */
  409. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  410. /* SCCS information: %W%    %G% - NCSA */
  411.  
  412. /* #include "all.h" */
  413. /* #include "newext.h" */
  414.  
  415. int 
  416. strip_wspace (s)
  417.                 /* returns the length */
  418.     char           *s;
  419.                 /* input: string to strip
  420.                    returns: stripped string with s[0]
  421.                         the first non-whitespace
  422.                         character */
  423. {
  424. /* Implementation note(s):
  425.     1. Assumes that s is not NULL and the string is NULL
  426.        terminated.
  427. */
  428.  
  429.     register int    i, j, k;
  430.  
  431.         /* strip off trailing white space */
  432.     if ((i = strlen (s)) == 0)
  433.         return (0);
  434.     while (--i >= 0 && (s[i] == ' ' || s[i] == '\t'));
  435.     s[++i] = '\0';
  436.     if (i == 0)
  437.         return (0);
  438.  
  439.         /* strip off leading white space */
  440.     if (s[0] != ' ' && s[0] != '\t')
  441.         return (i);
  442.     for (j = 0; s[j] == ' ' || s[j] == '\t'; j++);
  443.     for (k = 0; k < i - j; k++)
  444.         s[k] = s[k + j];
  445.     s[i - j] = '\0';
  446.     return ((i - j));
  447. }
  448. /* EOF */
  449. /* cat > src+obj/new/tty_write.c << "EOF" */
  450. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  451. /* tty_write: write message to tty subwindow        */
  452. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  453. /* SCCS information: %W%    %G% - NCSA */
  454.  
  455. /* #include "all.h" */
  456. /* #include "newext.h" */
  457.  
  458. void 
  459. tty_write (msg)
  460.     char           *msg;
  461. {
  462.  
  463.     ttysw_input (ttysw, msg, strlen (msg));
  464. }
  465. /* EOF */
  466. /* cat > src+obj/new/window_corner.c << "EOF" */
  467. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  468. /* window_corner: get corner coordinates of frame     */
  469. /*          PIXWIN                */
  470. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  471. /* SCCS information: %W%    %G% - NCSA */
  472.  
  473. /* #include "all.h" */
  474. /* #include "newext.h" */
  475.  
  476. int
  477. window_corner (frame, vside, hside, x_corner, y_corner)
  478.                 /* returns: 0 = success
  479.                        -1 = failure */
  480.     Frame           frame;
  481.                 /* input: frame to get corner corrdinates of */
  482.     enum rect_vertical vside;
  483.                 /* input: which vertical side for corner */
  484.     enum rect_horizontal hside;
  485.                 /* input: which horizontal side for corner */
  486.     int            *x_corner;
  487.                 /* returns: x value of PIXWIN corner if no error */
  488.     int            *y_corner;
  489.                 /* returns: y value of PIXWIN corner if no error */
  490. {
  491.     Rect           *rect_frame;
  492.  
  493.     if (frame == NULL)
  494.         return (-1);
  495.     rect_frame = (Rect *) window_get (frame, WIN_RECT);
  496.  
  497.     *x_corner = rect_frame->r_left;
  498.     *y_corner = rect_frame->r_top;
  499.     switch (vside)
  500.     {
  501.         case LEFT:
  502.             switch (hside)
  503.             {
  504.                 case TOP:
  505.                     break;
  506.                 case BOTTOM:
  507.                     *y_corner += rect_frame->r_height;
  508.                     break;
  509.                 default:
  510.                     return (-1);
  511.             }
  512.             break;
  513.         case RIGHT:
  514.             *x_corner += rect_frame->r_width;
  515.             switch (hside)
  516.             {
  517.                 case TOP:
  518.                     break;
  519.                 case BOTTOM:
  520.                     *y_corner += rect_frame->r_height;
  521.                     break;
  522.                 default:
  523.                     return (-1);
  524.             }
  525.             break;
  526.         default:
  527.             return (-1);
  528.     }
  529.     return (0);
  530. }
  531. /* EOF */
  532. /* cat > src+obj/new/word_count.c << "EOF" */
  533. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  534. /* word_count: number of words in string. White space    */
  535. /*           is space or tab.                */
  536. /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ */
  537. /* SCCS information: %W%    %G% - NCSA */
  538.  
  539. /* #include "all.h" */
  540. /* #include "newext.h" */
  541.  
  542. int 
  543. word_count (s)
  544.                 /* returns: the number of words in
  545.                         the input string */
  546.     char           *s;
  547. {
  548.     register int    count, word, c;
  549.  
  550.     count = 0;
  551.     word = 0;
  552.     while ((c = *s++) != NULL)
  553.         if (c == ' ' || c == '\t')    /* white space */
  554.             word = 0;
  555.         else if (!word)
  556.         {        /* not white space */
  557.             word = 1;
  558.             count++;
  559.         }
  560.     return (count);
  561. }
  562. /* EOF */
  563.